#!/usr/bin/env python3
import numpy as np

#逻辑与
samples_and = [
    [0, 0, 0],
    [1, 0, 0],
    [0, 1, 0],
    [1, 1, 1],
]

#逻辑或
samples_or = [
    [0, 0, 0],
    [1, 0, 1],
    [0, 1, 1],
    [1, 1, 1],
]


#逻辑异或
samples_xor = [
    [0, 0, 0],
    [1, 0, 1],
    [0, 1, 1],
    [1, 1, 0],
]


#感知机的学习规则：所谓学习规则就是修改神经网络的权值和偏置值的方法和过程（也称这种过程是训练算法）
#感知机的学习规则属于有监督学习
def perceptron(samples):
    #初始参数
    #权重系数
    w = np.array([1, 2])
    #偏置
    b = 0
    a = 1

    for i in range(10):
        for j in range(4):
            #取每个行向量的前两列
            x = np.array(samples[j][:2])
            #（三目运算）激励函数：阶跃函数
            y = 1 if np.dot(w, x) + b > 0 else 0
            #取每个行向量的第三列
            d = np.array(samples[j][2])

            #损失函数对b的梯度为：-(t-y)
            # (d-y)是梯度下降的方向 a是学习率
            delta_b = a*(d-y)
            # 损失函数对w的梯度为：-(t-y)*x
            delta_w = a*(d-y)*x

            #delta_b delta_w均为0时，表示已经收敛
            print('epoch {} sample {}  [{} {} {} {} {} {} {}]'.format(
                i, j, w[0], w[1], b, y, delta_w[0], delta_w[1], delta_b
            ))
            w = w + delta_w
            b = b + delta_b


if __name__ == '__main__':
    print('logical and')
    perceptron(samples_and)
    print('logical or')
    perceptron(samples_or)
    print('logical xor')
    perceptron(samples_xor)
